{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_y = [[0 0 1 0 0 0 0 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0\n",
      "  0 0 1 0 0 1 1 0 0 0 0 1 0 0 1 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1\n",
      "  0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 1 1\n",
      "  1 1 1 1 0 0 0 0 0 1 0 0 0 1 0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 1 0\n",
      "  1 1 1 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0 1\n",
      "  0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0]]\n",
      "y = [1], it's a cat` picture\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from lr_utils import load_dataset\n",
    "\n",
    "#train_set_x_orig ：保存的是训练集里面的图像数据（本训练集有209张64x64的图像）。\n",
    "#train_set_y_orig ：保存的是训练集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "#test_set_x_orig ：保存的是测试集里面的图像数据（本训练集有50张64x64的图像）。\n",
    "#test_set_y_orig ： 保存的是测试集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。\n",
    "#classes ： 保存的是以bytes类型保存的两个字符串数据，数据为：[b’non-cat’ b’cat’]。\n",
    "\n",
    "train_set_x_orig,train_set_y,test_set_x_orig,test_set_y,classes = load_dataset()\n",
    "\n",
    "index = 25\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print(\"train_set_y = \"+ str(train_set_y))  #你也可以看一下训练集里面的标签是什么样的。\n",
    "\n",
    "#打印出当前的训练标签值\n",
    "#使用np.squeeze的目的是压缩维度，【未压缩】train_set_y[:,index]的值为[1] , \n",
    "#【压缩后】np.squeeze(train_set_y[:,index])的值为1\n",
    "#print(\"【使用np.squeeze：\" + str(np.squeeze(train_set_y[:,index])) + \"，不使用np.squeeze： \" + str(train_set_y[:,index]) + \"】\")\n",
    "#只有压缩后的值才能进行解码操作\n",
    "print(\"y = \"+str(train_set_y[:,index])+\", it's a \"+classes[np.squeeze(train_set_y[:,index])].decode(\"utf-8\")+\"` picture\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集的数量：m_train = 209\n",
      "测试集的数量：m_test = 50\n",
      "每张图片的宽/高: num_px = 64\n",
      "每张图片的大小：（64, 64, 3\n",
      "训练集_图片的维数：(209, 64, 64, 3)\n",
      "训练集_标签的维数: (1, 209)\n",
      "测试集_图片的维数：(50, 64, 64, 3)\n",
      "测试集_标签的维数：(1, 50)\n"
     ]
    }
   ],
   "source": [
    "m_train = train_set_y.shape[1] #训练集里图片的数量。\n",
    "m_test = test_set_y.shape[1]   #测试集里图片的数量。\n",
    "num_px = train_set_x_orig.shape[1]  #训练、测试集里面的图片的宽度和高度（均为64x64）。\n",
    "\n",
    "#现在看一看我们加载的东西的具体情况\n",
    "print(\"训练集的数量：m_train = \"+str(m_train))\n",
    "print(\"测试集的数量：m_test = \"+str(m_test))\n",
    "print(\"每张图片的宽/高: num_px = \"+str(num_px))\n",
    "print(\"每张图片的大小：（\" + str(num_px) + \", \" + str(num_px)+\", 3\")\n",
    "print(\"训练集_图片的维数：\" + str(train_set_x_orig.shape))\n",
    "print(\"训练集_标签的维数: \" + str(train_set_y.shape))\n",
    "print(\"测试集_图片的维数：\" + str(test_set_x_orig.shape))\n",
    "print(\"测试集_标签的维数：\" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集降维最后的维度： (12288, 209)\n",
      "训练集_标签的维数： (1, 209)\n",
      "测试集降维之后的维数： (12288, 50)\n",
      "测试集_标签的维数： (1, 50)\n"
     ]
    }
   ],
   "source": [
    "#X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置\n",
    "#将训练集的维度降低并转置。\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "#将测试集的维度降低并转置。\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n",
    "print(\"训练集降维最后的维度： \" + str(train_set_x_flatten.shape))\n",
    "print(\"训练集_标签的维数： \" + str(train_set_y.shape))\n",
    "print(\"测试集降维之后的维数： \" + str(test_set_x_flatten.shape))\n",
    "print(\"测试集_标签的维数： \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "#标准化数据集\n",
    "train_set_x = train_set_x_flatten / 255\n",
    "test_set_x = test_set_x_flatten / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================测试sigmoid=================\n",
      "sigmoid(0) = 0.5\n",
      "sigmoid(9.2) = 0.9998989708060922\n"
     ]
    }
   ],
   "source": [
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    参数：\n",
    "        z - 任何大小的标量或numpy数组\n",
    "        \n",
    "    返回：\n",
    "        s - sigmoid（z）\n",
    "    \"\"\"\n",
    "    s = 1 / (1 + np.exp(-z))\n",
    "    return s\n",
    "\n",
    "#测试sigmoid()\n",
    "print(\"================测试sigmoid=================\")\n",
    "print(\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print(\"sigmoid(9.2) = \" + str(sigmoid(9.2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.]\n",
      " [0.]]\n",
      "b = 0\n"
     ]
    }
   ],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    次函数为w创建一个维度为（dim,1)的0向量，并将b初始化为0\n",
    "    参数：\n",
    "        dim - 我们想要的w矢量的大小（或者这种情况下的参数数量）\n",
    "        \n",
    "    返回：\n",
    "        w - 维度为(dim,1)初始化向量\n",
    "        b - 初始化的标量（对应于偏差）\n",
    "    \"\"\"\n",
    "    w = np.zeros(shape = (dim,1))\n",
    "    b = 0\n",
    "    #使用断言来确保数据是正确的\n",
    "    assert(w.shape == (dim,1)) #w的维度是(dim,1)\n",
    "    assert(isinstance(b,float) or isinstance(b,int)) #b的类型是float或者是int\n",
    "    \n",
    "    return (w,b)\n",
    "dim = 2 \n",
    "w,b = initialize_with_zeros(dim)\n",
    "print(\"w = \" + str(w))\n",
    "print(\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=======================测试propagate=======================\n",
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "def propagate(w,b,X,Y):\n",
    "    \"\"\"\n",
    "    实现前向和后向传播的成本函数及其梯度\n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 矩阵类型为（num_px * num_px * 3，训练数量）\n",
    "        Y - 真正的标签矢量（如果非猫则为0，猫则为1），矩阵维度为（1，训练数据数量）\n",
    "    \n",
    "    返回：\n",
    "        cost - 逻辑回归的负对数似然成本\n",
    "        dw   - 相对于w的损失梯度，因此与w形状相同\n",
    "        db   - 相对于b的损失梯度，因此与b形状相同\n",
    "    \"\"\"\n",
    "    m = X.shape[1]\n",
    "    \n",
    "    #正向传播\n",
    "    A = sigmoid(np.dot(w.T,X) + b)  #计算激活值\n",
    "    cost = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1-A))) #计算成本\n",
    "    \n",
    "    #反向传播\n",
    "    dw = (1/m) * np.dot(X, (A-Y).T)\n",
    "    db = (1/m) * np.sum(A-Y)\n",
    "    \n",
    "    #使用断言确保数据正确\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)  #dtype 数组元素的类型\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    #  创建一个字典，把dw和db保存起来\n",
    "    grads = {\n",
    "        \"dw\": dw,\n",
    "        \"db\": db\n",
    "    }\n",
    "    return (grads,cost)\n",
    "\n",
    "#测试propagate\n",
    "print(\"=======================测试propagate=======================\")\n",
    "#初始化一些参数\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print(\"dw = \" + str(grads[\"dw\"]))\n",
    "print(\"db = \" + str(grads[\"db\"]))\n",
    "print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=====================测试optimize======================\n",
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n"
     ]
    }
   ],
   "source": [
    "def optimize(w, b ,X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    \"\"\"\n",
    "    次函数通过运行梯度下降算法来优化w和b\n",
    "    \n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3， 1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 维度为（num_px * num_px * 3，训练数据的数量）的数组。\n",
    "        Y - 真正的标量矢量（如果非猫则为0，猫则为1），矩阵维度为（1，训练数据数量）\n",
    "        num_iterations - 优化循环的迭代次数\n",
    "        learning_rate - 梯度下降更新规则的学习率\n",
    "        print_cost - 每100步打印一次损失值\n",
    "        \n",
    "    返回：\n",
    "        params - 包含权重w和偏差b的字典\n",
    "        grads  - 包含权重和偏差相对于成本函数的梯度字典\n",
    "        costs  - 优化期间计算的所有成本列表，将用于绘制学习曲线\n",
    "        \n",
    "    提示：\n",
    "    需要写两个步骤并遍历它们：\n",
    "        1. 计算当前参数的成本和梯度，使用propagate()\n",
    "        2. 使用w和b的梯度下降法更新参数\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    for i in range(num_iterations):\n",
    "        grads,cost = propagate(w, b, X, Y)\n",
    "        \n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        \n",
    "        #记录成本\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "            \n",
    "        #打印成本数据\n",
    "        if(print_cost) and (i % 100 == 0):\n",
    "            print(\"迭代次数：%i， 误差值： %f \" % (i,cost))\n",
    "            \n",
    "    params = {\n",
    "         \"w\" : w,\n",
    "         \"b\" : b\n",
    "    }\n",
    "    grads = {\n",
    "         \"dw\": dw,\n",
    "         \"db\": db\n",
    "    }\n",
    "    return (params, grads, costs)\n",
    "    \n",
    "# 测试optimize\n",
    "print(\"=====================测试optimize======================\")\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "params, grads, costs = optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009,print_cost=False)\n",
    "print(\"w = \" + str(params[\"w\"]))\n",
    "print(\"b = \" + str(params[\"b\"]))\n",
    "print(\"dw = \" + str(grads[\"dw\"]))\n",
    "print(\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=======================测试predict======================\n",
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "def predict(w, b, X):\n",
    "    \"\"\"\n",
    "    使用学习逻辑回归参数logistic(w,b)预测标签是0还是1，分两步：\n",
    "        1. 计算 Yˆ=A=σ(wTX+b)\n",
    "        2. 将a的值变为0（若激活值<= 0.5）或者为1（激活值> 0.5），\n",
    "\n",
    "    \n",
    "    参数：\n",
    "        w - 权重，大小不等的数组（num_px * num_px * 3， 1）\n",
    "        b - 偏差，一个标量\n",
    "        X - 维度为（num_px * num_px * 3，训练数据的数量）的数组\n",
    "        \n",
    "    返回：\n",
    "        Y_prediction - 包含X中所有图片的所有预测[0|1]的一个numpy数组（向量）\n",
    "        \n",
    "    \"\"\"\n",
    "    m = X.shape[1] #图片的数量\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0],1)\n",
    "    \n",
    "    #计算预测猫在图片中出现的概率\n",
    "    A = sigmoid(np.dot(w.T,X) + b)\n",
    "    for i in range(A.shape[1]):\n",
    "        #将概率a [0，i]转换为实际预测p [0，i]\n",
    "        Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0\n",
    "    \n",
    "    #使用断言\n",
    "    assert(Y_prediction.shape == (1,m))\n",
    "    \n",
    "    return Y_prediction\n",
    "\n",
    "#测试predict\n",
    "print(\"=======================测试predict======================\")\n",
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([1,0])\n",
    "print(\"predictions = \" + str(predict(w,b,X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================测试model========================\n",
      "迭代次数：0， 误差值： 0.693147 \n",
      "迭代次数：100， 误差值： 0.584508 \n",
      "迭代次数：200， 误差值： 0.466949 \n",
      "迭代次数：300， 误差值： 0.376007 \n",
      "迭代次数：400， 误差值： 0.331463 \n",
      "迭代次数：500， 误差值： 0.303273 \n",
      "迭代次数：600， 误差值： 0.279880 \n",
      "迭代次数：700， 误差值： 0.260042 \n",
      "迭代次数：800， 误差值： 0.242941 \n",
      "迭代次数：900， 误差值： 0.228004 \n",
      "迭代次数：1000， 误差值： 0.214820 \n",
      "迭代次数：1100， 误差值： 0.203078 \n",
      "迭代次数：1200， 误差值： 0.192544 \n",
      "迭代次数：1300， 误差值： 0.183033 \n",
      "迭代次数：1400， 误差值： 0.174399 \n",
      "迭代次数：1500， 误差值： 0.166521 \n",
      "迭代次数：1600， 误差值： 0.159305 \n",
      "迭代次数：1700， 误差值： 0.152667 \n",
      "迭代次数：1800， 误差值： 0.146542 \n",
      "迭代次数：1900， 误差值： 0.140872 \n",
      "训练集准确性：  99.04306220095694 %\n",
      "测试集准确性：  70.0 %\n"
     ]
    }
   ],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    \"\"\"\n",
    "    通过调用之前实现的函数来构建逻辑回归模型\n",
    "    \n",
    "    参数：\n",
    "        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集\n",
    "        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集\n",
    "        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集\n",
    "        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集\n",
    "        num_iterations  - 表示用于优化参数的迭代次数的超参数\n",
    "        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数\n",
    "        print_cost  - 设置为true以每100次迭代打印成本\n",
    "\n",
    "    返回：\n",
    "        d - 包含有关模型信息的字典\n",
    "        \n",
    "    \"\"\"\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
    "    \n",
    "    parameters, grads, costs = optimize(w, b, X_train,Y_train, num_iterations, learning_rate, print_cost)\n",
    "    \n",
    "    #从字典参数中检索参数w和b\n",
    "    w,b = parameters[\"w\"], parameters[\"b\"]\n",
    "    \n",
    "    #预测测试/训练集的例子\n",
    "    Y_prediction_test = predict(w,b,X_test)\n",
    "    Y_prediction_train = predict(w,b,X_train)\n",
    "    \n",
    "    #打印训练后的准确性\n",
    "    print(\"训练集准确性： \", format(100 - np.mean(np.abs(Y_prediction_train - Y_train))*100),\"%\")\n",
    "    print(\"测试集准确性： \", format(100 - np.mean(np.abs(Y_prediction_test - Y_test))*100),\"%\")\n",
    "    \n",
    "    d = {\n",
    "        \"costs\": costs,\n",
    "        \"Y_prediction_test\": Y_prediction_test,\n",
    "        \"Y_prediction_train\": Y_prediction_train,\n",
    "        \"w\": w,\n",
    "        \"b\": b,\n",
    "        \"learning_rate\": learning_rate,\n",
    "        \"num_iterations\": num_iterations\n",
    "    }\n",
    "    return d\n",
    "\n",
    "print(\"======================测试model========================\")\n",
    "#加载真是数据，进行模型测试\n",
    "d = model(train_set_x,train_set_y,test_set_x,test_set_y,num_iterations=2000,learning_rate=0.005,print_cost=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制图\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate = \" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "learning_rate is 0.01\n",
      "训练集准确性：  99.52153110047847 %\n",
      "测试集准确性：  68.0 %\n",
      "\n",
      "----------------------------\n",
      "\n",
      "learning_rate is 0.001\n",
      "训练集准确性：  88.99521531100478 %\n",
      "测试集准确性：  64.0 %\n",
      "\n",
      "----------------------------\n",
      "\n",
      "learning_rate is 0.0001\n",
      "训练集准确性：  68.42105263157895 %\n",
      "测试集准确性：  36.0 %\n",
      "\n",
      "----------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "print(type(models))\n",
    "for i in learning_rates:\n",
    "    print(\"learning_rate is \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print('\\n'+\"----------------------------\"+'\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]),label = str(models[str(i)][\"learning_rate\"]))\n",
    "    \n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center',shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-97-a5244fc3d03c>, line 8)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-97-a5244fc3d03c>\"\u001b[1;36m, line \u001b[1;32m8\u001b[0m\n\u001b[1;33m    my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "## START CODE HERE ##\n",
    "my_image = \"mao.jpg\" # change this to the name of your image file \n",
    "my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n",
    "## END CODE HERE ##\n",
    " \n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(plt.imread(fname)\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))\n",
    "my_predicted_image = predict(my_image, my_label_y, parameters)\n",
    " \n",
    "plt.imshow(image)\n",
    "print (\"y = \" + str(np.squeeze(my_predicted_image)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
